package com.event.management.backend.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.event.management.backend.domain.Event;
import com.event.management.backend.dto.EventDTO;
import com.event.management.backend.dto.EventQueryParam;
import com.event.management.backend.mapper.EventMapper;
import com.event.management.backend.service.EventService;
import com.event.management.backend.util.UrlUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 活动服务实现类
 */
@Service
public class EventServiceImpl extends ServiceImpl<EventMapper, Event> implements EventService {

    @Override
    public IPage<EventDTO> getEventPage(EventQueryParam queryParam) {
        // 构建分页参数
        Page<Event> page = new Page<>(queryParam.getPageNum(), queryParam.getPageSize());
        
        // 构建查询条件
        LambdaQueryWrapper<Event> queryWrapper = new LambdaQueryWrapper<>();
        
        // 关键词搜索（标题、描述、地点）
        if (StringUtils.hasText(queryParam.getKeyword())) {
            queryWrapper.like(Event::getTitle, queryParam.getKeyword())
                    .or()
                    .like(Event::getDescription, queryParam.getKeyword())
                    .or()
                    .like(Event::getLocation, queryParam.getKeyword());
        }
        
        // 按状态筛选
        if (StringUtils.hasText(queryParam.getStatus())) {
            queryWrapper.eq(Event::getStatus, queryParam.getStatus());
        }
        
        // 按创建者筛选
        if (queryParam.getCreatorId() != null) {
            queryWrapper.eq(Event::getCreatorId, queryParam.getCreatorId());
        }
        
        // 按分类筛选
        if (StringUtils.hasText(queryParam.getCategory())) {
            queryWrapper.eq(Event::getCategory, queryParam.getCategory());
        }
        
        // 按标签筛选（模糊匹配，因为标签是逗号分隔的）
        if (StringUtils.hasText(queryParam.getTag())) {
            queryWrapper.like(Event::getTags, queryParam.getTag());
        }
        
        // 排序规则
        if (Boolean.TRUE.equals(queryParam.getUseRecommendSort())) {
            // 如果使用推荐排序，按照推荐分数降序，创建时间降序
            queryWrapper.orderByDesc(Event::getRecommendScore, Event::getCreatedAt);
        } else {
            // 默认按创建时间降序排序
            queryWrapper.orderByDesc(Event::getCreatedAt);
        }
        
        // 执行查询
        IPage<Event> resultPage = this.page(page, queryWrapper);
        
        // 转换为DTO
        List<EventDTO> records = resultPage.getRecords().stream()
                .map(this::convertToDTO)
                .collect(Collectors.toList());
        
        // 构建返回结果
        IPage<EventDTO> dtoPage = new Page<>(
                resultPage.getCurrent(),
                resultPage.getSize(),
                resultPage.getTotal()
        );
        dtoPage.setRecords(records);
        
        return dtoPage;
    }

    @Override
    public EventDTO getEventById(Long id) {
        if (id == null) {
            return null;
        }
        
        // 使用LambdaQueryWrapper查询未删除的活动
        LambdaQueryWrapper<Event> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Event::getId, id);
        queryWrapper.eq(Event::getIsDeleted, false);
        
        Event event = this.getOne(queryWrapper);
        if (event == null) {
            return null;
        }
        
        EventDTO eventDTO = convertToDTO(event);
        
        // 这里可以添加其他关联数据，如活动创建者信息等
        // 例如可以从用户服务获取创建者信息，或记录查看记录等
        // userService.getUsernameById(event.getCreatorId());
        
        return eventDTO;
    }

    @Override
    public Long addEvent(EventDTO eventDTO) {
        Event event = new Event();
        BeanUtils.copyProperties(eventDTO, event);
        
        // 处理封面URL，确保不超过数据库长度限制
        if (event.getCover() != null) {
            event.setCover(UrlUtils.processUrl(event.getCover()));
        }
        
        // 设置创建者ID为当前登录用户
        event.setCreatorId(Long.valueOf(StpUtil.getLoginIdAsString()));
        
        // 初始化浏览量为0
        if (event.getViewCount() == null) {
            event.setViewCount(0);
        }
        
        // 初始化推荐分数为0
        if (event.getRecommendScore() == null) {
            event.setRecommendScore(0.0f);
        }
        
        // 处理标签（去除多余空格，限制长度等）
        if (event.getTags() != null) {
            String processedTags = processTagsField(event.getTags());
            event.setTags(processedTags);
        }
        
        // 显式设置状态值确保完全匹配数据库枚举
        if (eventDTO.getStatus() == null) {
            event.setStatus(Event.EventStatus.DRAFT);
        } else {
            // 确保状态值完全符合枚举值
            switch (eventDTO.getStatus()) {
                case Event.EventStatus.DRAFT:
                    event.setStatus(Event.EventStatus.DRAFT);
                    break;
                case Event.EventStatus.ONLINE:
                    event.setStatus(Event.EventStatus.ONLINE);
                    break;
                case Event.EventStatus.OFFLINE:
                    event.setStatus(Event.EventStatus.OFFLINE);
                    break;
                default:
                    event.setStatus(Event.EventStatus.DRAFT);
                    break;
            }
        }
        
        this.save(event);
        return event.getId();
    }

    @Override
    public boolean updateEvent(Long id, EventDTO eventDTO) {
        Event event = this.getById(id);
        if (event == null) {
            return false;
        }
        
        // 保存原始值，以防被覆盖
        String originalStatus = event.getStatus();
        Integer originalViewCount = event.getViewCount();
        Float originalRecommendScore = event.getRecommendScore();
        
        // 先复制基本属性
        BeanUtils.copyProperties(eventDTO, event);
        
        // 处理封面URL，确保不超过数据库长度限制
        if (event.getCover() != null) {
            event.setCover(UrlUtils.processUrl(event.getCover()));
        }
        
        // 确保浏览量不被重置
        if (event.getViewCount() == null || eventDTO.getViewCount() == null) {
            event.setViewCount(originalViewCount);
        }
        
        // 处理推荐分数
        if (event.getRecommendScore() == null) {
            event.setRecommendScore(originalRecommendScore);
        }
        
        // 处理标签
        if (event.getTags() != null) {
            String processedTags = processTagsField(event.getTags());
            event.setTags(processedTags);
        }
        
        // 单独处理状态字段，确保完全符合数据库枚举值
        if (eventDTO.getStatus() == null) {
            event.setStatus(originalStatus);
        } else {
            // 确保状态值完全符合枚举值
            switch (eventDTO.getStatus()) {
                case Event.EventStatus.DRAFT:
                    event.setStatus(Event.EventStatus.DRAFT);
                    break;
                case Event.EventStatus.ONLINE:
                    event.setStatus(Event.EventStatus.ONLINE);
                    break;
                case Event.EventStatus.OFFLINE:
                    event.setStatus(Event.EventStatus.OFFLINE);
                    break;
                default:
                    event.setStatus(originalStatus);
                    break;
            }
        }
        
        event.setId(id); // 确保ID不被覆盖
        
        return this.updateById(event);
    }

    @Override
    public boolean deleteEvent(Long id) {
        return this.removeById(id);
    }
    
    @Override
    public Integer getTicketCount(Long eventId) {
        if (eventId == null) {
            return 0;
        }
        
        // 通过mapper直接查询票种数量
        return baseMapper.selectTicketCountByEventId(eventId);
    }
    
    @Override
    public boolean checkEventManagePermission(Long eventId) {
        // 获取当前登录用户ID
        Long userId = StpUtil.getLoginIdAsLong();
        
        // 如果是管理员，直接返回true
        if (StpUtil.hasRole("admin")) {
            return true;
        }
        
        // 查询活动是否存在且未被删除
        Event event = getById(eventId);
        if (event == null || event.getIsDeleted()) {
            return false;
        }
        
        // 检查是否是活动创建者
        return event.getCreatorId().equals(userId);
    }
    
    /**
     * 将实体转换为DTO
     * @param event 活动实体
     * @return 活动DTO
     */
    private EventDTO convertToDTO(Event event) {
        if (event == null) {
            return null;
        }
        
        EventDTO eventDTO = new EventDTO();
        BeanUtils.copyProperties(event, eventDTO);
        
        // 获取活动关联的票种数量
        Integer ticketCount = this.getTicketCount(event.getId());
        eventDTO.setTicketCount(ticketCount);
        
        return eventDTO;
    }
    
    /**
     * 处理标签字段，格式化并确保不超过限制长度
     * @param tags 原始标签字符串
     * @return 处理后的标签字符串
     */
    private String processTagsField(String tags) {
        if (tags == null || tags.isEmpty()) {
            return "";
        }
        
        // 分割标签，去除空格，重新组合
        String[] tagArray = tags.split(",");
        StringBuilder sb = new StringBuilder();
        int count = 0;
        
        for (String tag : tagArray) {
            String trimmedTag = tag.trim();
            if (!trimmedTag.isEmpty()) {
                if (count > 0) {
                    sb.append(",");
                }
                sb.append(trimmedTag);
                count++;
                
                // 限制标签数量，最多10个
                if (count >= 10) {
                    break;
                }
            }
        }
        
        // 确保总长度不超过数据库限制（255字符）
        String result = sb.toString();
        if (result.length() > 255) {
            result = result.substring(0, 255);
        }
        
        return result;
    }
    
    @Override
    public void incrementViewCount(Long eventId) {
        if (eventId == null) {
            return;
        }
        
        // 使用SQL直接更新浏览量，避免并发问题
        this.baseMapper.incrementViewCount(eventId);
    }
} 